home *** CD-ROM | disk | FTP | other *** search
/ Die Speccy' 97 / Die Speccy' 97.iso / amiga_system / the_aminet / comm / bbs / wwbbs31_source.lha / WWBBS / RxSrc / filebase_xfer.c < prev    next >
C/C++ Source or Header  |  1995-03-30  |  14KB  |  432 lines
  1. #include <exec/types.h>
  2. #include <exec/exec.h>
  3. #include <libraries/wwbbs.h>
  4. #include <ctype.h>
  5. #include <math.h>
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9.  
  10. #include <proto/dos.h>
  11. #include <proto/exec.h>
  12. #include <proto/rexxsyslib.h>
  13. #include <proto/wwbbs.h>
  14.  
  15. #include "rx.h"
  16.  
  17. #include "filebase.h"
  18.  
  19. void Upload(BYTE *id)
  20.     {
  21.         BOOL local=FALSE;
  22.         BYTE user[33];
  23.         strcpy(user,"");
  24.         GetStatusTags(STTAG_Name,id,STTAG_UserName,user,STTAG_Local,&local,TAG_END);
  25.         if(strlen(user))
  26.             {
  27.                 if(!local)
  28.                     {
  29.                         if(strlen(file_area))
  30.                             {
  31.                                 BYTE protocol[33];
  32.                                 strcpy(protocol,"");
  33.                                 GetUserTags(USRTAG_Name,user,USRTAG_Protocol,protocol,TAG_END);
  34.                                 if(strlen(protocol))
  35.                                     {
  36.                                         BYTE cmd[256];
  37.                                         BOOL batch=FALSE,bidirectional=FALSE;
  38.                                         strcpy(cmd,"");
  39.                                         if(GetConfigTags(CFGTAG_Path,"Protocols",CFGTAG_Name,protocol,PRTAG_ReceiveCommand,cmd,PRTAG_Batch,&batch,PRTAG_Bidirectional,&bidirectional,TAG_END))
  40.                                             {
  41.                                                 ULONG dsr=0,dfs=0;
  42.                                                 BOOL readonly=FALSE;
  43.                                                 BYTE directory[256];
  44.                                                 strcpy(directory,"");
  45.                                                 if(GetConfigTags(CFGTAG_Path,file_path,CFGTAG_Name,file_area,FBTAG_Directory,directory,FBTAG_DiskSpaceRequired,&dsr,FBTAG_ReadOnly,&readonly,TAG_END))
  46.                                                     {
  47.                                                         if(!readonly)
  48.                                                             {
  49.                                                                 {
  50.                                                                     BPTR lock;
  51.                                                                     if(lock=Lock(directory,SHARED_LOCK))
  52.                                                                         {
  53.                                                                             struct InfoData id;
  54.                                                                             if(Info(lock,&id))
  55.                                                                                 dfs=((id.id_NumBlocks-id.id_NumBlocksUsed)*id.id_BytesPerBlock)/1024;
  56.                                                                             UnLock(lock);
  57.                                                                         }
  58.                                                                 }
  59.                                                                 printf("~s\nFree disk space: %ldK\n",dfs);
  60.                                                                 if(!dsr || dfs>=dsr)
  61.                                                                     {
  62.                                                                         BOOL ok=TRUE;
  63.                                                                         BYTE filename[33];
  64.                                                                         strcpy(filename,"");
  65.                                                                         if(!batch)
  66.                                                                             {
  67.                                                                                 BYTE buff[33];
  68.                                                                                 printf("~p\nEnter file name.\n: ");
  69.                                                                                 if(GetLine(buff,32,NULL))
  70.                                                                                     strcpy(filename,FilePart(buff));
  71.                                                                                 else
  72.                                                                                     ok=FALSE;
  73.                                                                             }
  74.                                                                         if(bidirectional)
  75.                                                                             CreateFileList(id);
  76.                                                                         if(ok)
  77.                                                                             {
  78.                                                                                 printf("~s\nReady to receive files...\n~r");
  79.                                                                                 DoTransfer(id,cmd,filename);
  80.                                                                                 ProcessLogFile(id);
  81.                                                                                 GetFileDescriptions(id);
  82.                                                                             }
  83.                                                                         if(bidirectional)
  84.                                                                             DeleteFileList(id);
  85.                                                                     }
  86.                                                                 else
  87.                                                                     printf("~s\nThere is not enough disk space for uploads.\n");
  88.                                                             }
  89.                                                         else
  90.                                                             printf("~s\nThis file area is read only.\n");
  91.                                                     }
  92.                                             }
  93.                                         else
  94.                                             printf("~s\nUnable to get config for `%s' protocol.\n",protocol);
  95.                                     }
  96.                                 else
  97.                                     printf("~s\nPlease select a protocol first.\n");
  98.                             }
  99.                         else
  100.                             printf("~s\nPlease enter a file area first.\n");
  101.                     }
  102.                 else
  103.                     UploadFromDisk(id);
  104.             }
  105.     }
  106.  
  107. void Download(BYTE *id)
  108.     {
  109.         BOOL local=FALSE;
  110.         BYTE user[33];
  111.         strcpy(user,"");
  112.         GetStatusTags(STTAG_Name,id,STTAG_UserName,user,STTAG_Local,&local,TAG_END);
  113.         if(strlen(user))
  114.             {
  115.                 if(!local)
  116.                     {
  117.                         BYTE protocol[33];
  118.                         strcpy(protocol,"");
  119.                         GetUserTags(USRTAG_Name,user,USRTAG_Protocol,protocol,TAG_END);
  120.                         if(strlen(protocol))
  121.                             {
  122.                                 BYTE cmd[256];
  123.                                 BOOL batch=FALSE,bidirectional=FALSE;
  124.                                 strcpy(cmd,"");
  125.                                 if(GetConfigTags(CFGTAG_Path,"Protocols",CFGTAG_Name,protocol,PRTAG_SendCommand,cmd,PRTAG_Batch,&batch,PRTAG_Bidirectional,&bidirectional,TAG_END))
  126.                                     {
  127.                                         if(batch && CreateFileList(id))
  128.                                             {
  129.                                                 printf("~s\nSending files...\n~r");
  130.                                                 DoTransfer(id,cmd,"");
  131.                                                 ProcessLogFile(id);
  132.                                                 if(bidirectional)
  133.                                                     GetFileDescriptions(id);
  134.                                                 DeleteFileList(id);
  135.                                             }
  136.                                         else
  137.                                             {
  138.                                                 if(strlen(file_area))
  139.                                                     {
  140.                                                         if(file_current)
  141.                                                             {
  142.                                                                 if(Ask("Download current file",TRUE))
  143.                                                                     {
  144.                                                                         APTR group;
  145.                                                                         BYTE filename[33];
  146.                                                                         ULONG filesize=0;
  147.                                                                         strcpy(filename,"");
  148.                                                                         if(group=OpenFileGroup(file_path,file_area,SHARED_LOCK))
  149.                                                                             {
  150.                                                                                 BYTE *p=NULL;
  151.                                                                                 if(GetFileTags(group,FILTAG_ID,file_current,FILTAG_Name,&p,FILTAG_Size,&filesize,TAG_END))
  152.                                                                                     strcpy(filename,p);
  153.                                                                                 CloseFileGroup(group);
  154.                                                                             }
  155.                                                                         if(strlen(filename))
  156.                                                                             {
  157.                                                                                 BYTE baud[11];
  158.                                                                                 ULONG creditsfile=0,creditskilo=0;
  159.                                                                                 UBYTE ratiofile=0,ratiobyte=0;
  160.                                                                                 UWORD timeremaining=0;
  161.                                                                                 strcpy(baud,"");
  162.                                                                                 if((GetVar("BAUD",baud,10,NULL)!=-1) && atol(baud))
  163.                                                                                     {
  164.                                                                                         GetStatusTags(STTAG_Name,id,STTAG_TimeRemaining,&timeremaining,TAG_END);
  165.                                                                                         GetUserTags(USRTAG_Name,user,USRTAG_RatioFile,&ratiofile,USRTAG_RatioByte,&ratiobyte,USRTAG_FilesCredits,&creditsfile,USRTAG_KilosCredits,&creditskilo,TAG_END);
  166.                                                                                         if(!ratiofile || creditsfile)
  167.                                                                                             {
  168.                                                                                                 if(!ratiobyte || (creditskilo>=filesize/1024))
  169.                                                                                                     {
  170.                                                                                                         if(timeremaining*60>=filesize/(atol(baud)/10))
  171.                                                                                                             {
  172.                                                                                                                 BYTE directory[256];
  173.                                                                                                                 BOOL readonly=FALSE;
  174.                                                                                                                 strcpy(directory,"");
  175.                                                                                                                 GetConfigTags(CFGTAG_Path,file_path,CFGTAG_Name,file_area,FBTAG_Directory,directory,FBTAG_ReadOnly,&readonly,TAG_END);
  176.                                                                                                                 if(!bidirectional || (strlen(file_area) && !readonly))
  177.                                                                                                                     {
  178.                                                                                                                         BYTE filebuff[256];
  179.                                                                                                                         strcpy(filebuff,directory);
  180.                                                                                                                         AddPart(filebuff,filename,255);
  181.                                                                                                                         if(batch)
  182.                                                                                                                             {
  183.                                                                                                                                 FILE *fp;
  184.                                                                                                                                 BYTE filelist_file[64];
  185.                                                                                                                                 sprintf(filelist_file,"T:wwbbs_filelist.%s",id);
  186.                                                                                                                                 if(fp=fopen(filelist_file,"w"))
  187.                                                                                                                                     {
  188.                                                                                                                                         fprintf(fp,"%s\n",filebuff);
  189.                                                                                                                                         fclose(fp);
  190.                                                                                                                                     }
  191.                                                                                                                             }
  192.                                                                                                                         printf("~s\nSending file...\n~r");
  193.                                                                                                                         DoTransfer(id,cmd,(batch) ? "" : filebuff);
  194.                                                                                                                         ProcessLogFile(id);
  195.                                                                                                                         if(bidirectional)
  196.                                                                                                                             GetFileDescriptions(id);
  197.                                                                                                                         if(batch)
  198.                                                                                                                             DeleteFileList(id);
  199.                                                                                                                     }
  200.                                                                                                                 else
  201.                                                                                                                     printf("~s\nSince you are using a bidirectional protocol, you must change directories to\nensure that you do not upload to an invalid directory.\n");
  202.                                                                                                             }
  203.                                                                                                         else
  204.                                                                                                             printf("~s\nSorry, not enough time remaining.\n");
  205.                                                                                                     }
  206.                                                                                                 else
  207.                                                                                                     printf("~s\nSorry, not enough kilo credits.\n");
  208.                                                                                             }
  209.                                                                                         else
  210.                                                                                             printf("~s\nSorry, not enough file credits.\n");
  211.                                                                                     }
  212.                                                                             }
  213.                                                                         else
  214.                                                                             printf("~s\nUnable to access file.\n");
  215.                                                                     }
  216.                                                             }
  217.                                                         else
  218.                                                             printf("~s\nCurrent file does not exist.\n");
  219.                                                     }
  220.                                                 else
  221.                                                     printf("~s\nPlease enter a file area first.\n");
  222.                                             }
  223.                                     }
  224.                                 else
  225.                                     printf("~s\nUnable to get config for protocol `%s'.\n",protocol);
  226.                             }
  227.                         else
  228.                             printf("~s\nPlease select a protocol first.\n");
  229.                     }
  230.                 else
  231.                     printf("~s\nFor some reason, downloading from a local node is not allowed.\n");
  232.             }
  233.     }
  234.  
  235. ULONG CreateFileList(BYTE *id)
  236.     {
  237.         ULONG ret=0;
  238.         BYTE user[33];
  239.         strcpy(user,"");
  240.         GetStatusTags(STTAG_Name,id,STTAG_UserName,user,TAG_END);
  241.         if(strlen(user))
  242.             {
  243.                 BYTE baud[11];
  244.                 strcpy(baud,"");
  245.                 if((GetVar("BAUD",baud,10,NULL)!=-1) && atol(baud))
  246.                     {
  247.                         ULONG files=0,kilos=0,creditsfile=0,creditskilo=0;
  248.                         UWORD timeremaining=0;
  249.                         UBYTE ratiofile=0,ratiobyte=0;
  250.                         GetStatusTags(STTAG_Name,id,STTAG_TimeRemaining,&timeremaining,TAG_END);
  251.                         GetUserTags(USRTAG_Name,user,USRTAG_RatioByte,&ratiobyte,USRTAG_RatioFile,&ratiofile,USRTAG_FilesCredits,&creditsfile,USRTAG_KilosCredits,&creditskilo,TAG_END);
  252.                         if(file_taglist->lh_Head->ln_Succ && Ask("Download tagged files",TRUE))
  253.                             {
  254.                                 FILE *fp;
  255.                                 BYTE filelist_file[64];
  256.                                 sprintf(filelist_file,"T:wwbbs_filelist.%s",id);
  257.                                 if(fp=fopen(filelist_file,"w"))
  258.                                     {
  259.                                         BOOL ok,nocreditsfile=FALSE,nocreditskilo=FALSE,notime=FALSE;
  260.                                         printf("\n~hFile                             Size      \n~o");
  261.                                         {
  262.                                             struct FileTagNode *node;
  263.                                             for(node=(struct FileTagNode *) file_taglist->lh_Head;node->ftn_Node.ln_Succ;node=(struct FileTagNode *) node->ftn_Node.ln_Succ)
  264.                                                 {
  265.                                                     ok=TRUE;
  266.                                                     if(ratiofile)
  267.                                                         {
  268.                                                             if(files+1>creditsfile)
  269.                                                                 {
  270.                                                                     nocreditsfile=TRUE;
  271.                                                                     ok=FALSE;
  272.                                                                 }
  273.                                                         }
  274.                                                     if(ratiobyte)
  275.                                                         {
  276.                                                             if(kilos+(node->ftn_Size/1024)>creditskilo)
  277.                                                                 {
  278.                                                                     nocreditskilo=TRUE;
  279.                                                                     ok=FALSE;
  280.                                                                 }
  281.                                                         }
  282.                                                     if(((kilos+(node->ftn_Size/1024))*1024)/(atol(baud)/10)>timeremaining*60)
  283.                                                         {
  284.                                                             notime=TRUE;
  285.                                                             ok=FALSE;
  286.                                                         }
  287.                                                     if(ok)
  288.                                                         {
  289.                                                             printf("%-32s %ld\n",FilePart(node->ftn_Name),node->ftn_Size);
  290.                                                             fprintf(fp,"%s\n",node->ftn_Name);
  291.                                                             files++;
  292.                                                             kilos+=node->ftn_Size/1024;
  293.                                                         }
  294.                                                 }
  295.                                         }
  296.                                         printf("\nTotals: %ld files, %ld kilos, %d minutes\n",files,kilos,((kilos*1024)/(atol(baud)/10))/60);
  297.                                         if(nocreditsfile)
  298.                                             printf("~s\nSorry, not enough file credits.\n");
  299.                                         if(nocreditskilo)
  300.                                             printf("~s\nSorry, not enough kilo credits.\n");
  301.                                         if(notime)
  302.                                             printf("~s\nSorry, not enough time remaining.\n");
  303.                                         fclose(fp);
  304.                                         ret=files;
  305.                                     }
  306.                             }
  307.                     }
  308.             }
  309.         return(ret);
  310.     }
  311.  
  312. void DeleteFileList(BYTE *id)
  313.     {
  314.         BYTE file[64];
  315.         sprintf(file,"T:wwbbs_filelist.%s",id);
  316.         DeleteFile(file);
  317.     }
  318.  
  319. void DoTransfer(BYTE *id,BYTE *cmd,BYTE *filename)
  320.     {
  321.         BYTE user[33];
  322.         strcpy(user,"");
  323.         GetStatusTags(STTAG_Name,id,STTAG_UserName,user,TAG_END);
  324.         if(strlen(user))
  325.             {
  326.                 BPTR old_dir,new_dir;
  327.                 BYTE directory[256];
  328.                 BYTE log[64],filelist[64];
  329.                 strcpy(directory,"");
  330.                 if(strlen(file_area))
  331.                     GetConfigTags(CFGTAG_Path,file_path,CFGTAG_Name,file_area,FBTAG_Directory,directory,TAG_END);
  332.                 sprintf(log,"T:wwbbs_filelog.%s",id);
  333.                 sprintf(filelist,"T:wwbbs_filelist.%s",id);
  334.                 if(!strlen(file_area) || (new_dir=Lock(directory,SHARED_LOCK)))
  335.                     {
  336.                         if(strlen(file_area))
  337.                             old_dir=CurrentDir(new_dir);
  338.                         {
  339.                             char fullcmd[256],device[33],unit[11];
  340.                             ULONG unit_long=0;
  341.                             strcpy(fullcmd,"");
  342.                             strcpy(device,"");
  343.                             strcpy(unit,"");
  344.                             GetConfigTags(CFGTAG_Path,"Nodes",CFGTAG_Name,id,NDTAG_Device,device,NDTAG_Unit,&unit_long,TAG_END);
  345.                             sprintf(unit,"%ld",unit_long);
  346.                             {
  347.                                 char *p,*q[6],cmdbuff[256];
  348.                                 int i;
  349.                                 strcpy(cmdbuff,cmd);
  350.                                 q[0]=q[1]=q[2]=q[3]=q[4]=q[5]=NULL;
  351.                                 p=cmdbuff;
  352.                                 i=0;
  353.                                 while((i<6) && (p=strchr(p,'%')))
  354.                                     {
  355.                                         p++;
  356.                                         if(*p)
  357.                                             {
  358.                                                 switch(*p)
  359.                                                     {
  360.                                                         case 'D':
  361.                                                         case 'd':
  362.                                                             q[i]=device;
  363.                                                             i++;
  364.                                                             *p='s';
  365.                                                             break;
  366.                                                         case 'U':
  367.                                                         case 'u':
  368.                                                             q[i]=unit;
  369.                                                             i++;
  370.                                                             *p='s';
  371.                                                             break;
  372.                                                         case 'L':
  373.                                                         case 'l':
  374.                                                             q[i]=log;
  375.                                                             i++;
  376.                                                             *p='s';
  377.                                                             break;
  378.                                                         case 'F':
  379.                                                             q[i]=filelist;
  380.                                                             i++;
  381.                                                             *p='s';
  382.                                                             break;
  383.                                                         case 'f':
  384.                                                             q[i]=filename;
  385.                                                             i++;
  386.                                                             *p='s';
  387.                                                             break;
  388.                                                         case 'N':
  389.                                                         case 'n':
  390.                                                             q[i]=user;
  391.                                                             i++;
  392.                                                             *p='s';
  393.                                                             break;
  394.                                                     }
  395.                                                 p++;
  396.                                             }
  397.                                     }
  398.                                 sprintf(fullcmd,cmdbuff,q[0],q[1],q[2],q[3],q[4],q[5]);
  399.                             }
  400.                             {
  401.                                 LONG exitcode;
  402.                                 exitcode=SystemTags(fullcmd,TAG_END);
  403.                                 switch(exitcode)
  404.                                     {
  405.                                         case -1:
  406.                                             printf("~s\nUnable to execute protocol command.\n");
  407.                                             break;
  408.                                         case 0:
  409.                                             printf("~s\nTransfer successful.\n");
  410.                                             break;
  411.                                         case 1:
  412.                                         case 2:
  413.                                         case 3:
  414.                                         case 4:
  415.                                         case 5:
  416.                                             printf("~s\nTransfer aborted.\n");
  417.                                             break;
  418.                                         default:
  419.                                             printf("~s\nTransfer failed.\n");
  420.                                             break;
  421.                                     }
  422.                             }
  423.                         }
  424.                         if(strlen(file_area))
  425.                             {
  426.                                 CurrentDir(old_dir);
  427.                                 UnLock(new_dir);
  428.                             }
  429.                     }
  430.             }
  431.     }
  432.